2138-将字符串拆分为若干长度为 k 的组

Raphael Liu Lv10
  2023-09-13 00:47:26 2023-09-13 00:47:26 Created   2023-09-13 16:06:25 2023-09-13 16:06:25 Updated    

字符串 s 可以按下述步骤划分为若干长度为 k 的组：

  • 第一组由字符串中的前 k 个字符组成，第二组由接下来的 k 个字符串组成，依此类推。每个字符都能够成为 某一个 组的一部分。
  • 对于最后一组，如果字符串剩下的字符 不足 k 个，需使用字符 fill 来补全这一组字符。

注意，在去除最后一个组的填充字符 fill（如果存在的话）并按顺序连接所有的组后，所得到的字符串应该是 s 。

给你一个字符串 s ，以及每组的长度 k 和一个用于填充的字符 fill ，按上述步骤处理之后，返回一个字符串数组，该数组表示 s 分组后
每个组的组成情况 。

示例 1：

**输入：** s = "abcdefghi", k = 3, fill = "x"
**输出：** ["abc","def","ghi"]
**解释：**
前 3 个字符是 "abc" ，形成第一组。
接下来 3 个字符是 "def" ，形成第二组。
最后 3 个字符是 "ghi" ，形成第三组。
由于所有组都可以由字符串中的字符完全填充，所以不需要使用填充字符。
因此，形成 3 组，分别是 "abc"、"def" 和 "ghi" 。

示例 2：

**输入：** s = "abcdefghij", k = 3, fill = "x"
**输出：** ["abc","def","ghi","jxx"]
**解释：**
与前一个例子类似，形成前三组 "abc"、"def" 和 "ghi" 。
对于最后一组，字符串中仅剩下字符 'j' 可以用。为了补全这一组，使用填充字符 'x' 两次。
因此，形成 4 组，分别是 "abc"、"def"、"ghi" 和 "jxx" 。

提示：

  • 1 <= s.length <= 100
  • s 仅由小写英文字母组成
  • 1 <= k <= 100
  • fill 是一个小写英文字母

方法一：寻找每一组的起始下标

思路与算法

我们假设字符串 s 的长度为 n。由于分组后的字符串，除了最后一组以外，每一组的长度为 k，因此我们可以确定每一组字符串的起始下标，其中第 i 组的起始下标为 k\times i；基于此，我们就可以确定每一组的字符串对应 s 中的下标范围，即 [k\times i, \min((k + 1)\times i, n) - 1] 闭区间。

具体地，我们用数组 res 来保存每组字符串，并用 curr 维护当前组的起始下标。curr 的初值为 0，当 curr 为合法下标时，说明当前组字符串存在，我们将该组对应的子串 s[k\times i..\min((k + 1)\times i, n) - 1] 加入 res 的尾部，同时将 curr 加上 k 作为可能存在的下一组的起始下标。

最终，数组 res 的最后一个元素即为最后一组字符串，我们需要按要求使用填充字符 fill 将其长度补充至 k。上述操作完成后，我们返回 res 数组作为答案。

代码

[sol1-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
public:
    vector<string> divideString(string s, int k, char fill) {
        vector<string> res;   // 分组后的字符串
        int n = s.size();
        int curr = 0;   // 每个分组的起始下标
        // 拆分字符串
        while (curr < n) {
            res.push_back(s.substr(curr, k));
            curr += k;
        }
        // 尝试填充最后一组
        res.back() += string(k - res.back().length(), fill);
        return res;
    }
};
[sol1-Python3]
1
2
3
4
5
6
7
8
9
10
11
12
class Solution:
    def divideString(self, s: str, k: int, fill: str) -> List[str]:
        res = []   # 分组后的字符串
        n = len(s)
        curr = 0   # 每个分组的起始下标
        # 拆分字符串
        while curr < n:
            res.append(s[curr:curr+k])
            curr += k
        # 尝试填充最后一组
        res[-1] += fill * (k - len(res[-1]))
        return res

复杂度分析

  • 时间复杂度：O(\max(n, k))，其中 n 为字符串 s 的长度。即为对字符串分组并填充的时间复杂度。

  • 空间复杂度：O(1)，输出数组不计入空间复杂度。

 Comments
On this page
2138-将字符串拆分为若干长度为 k 的组